{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# COMPSCI 389: Introduction to Machine Learning\n", "# Generative AI\n", "\n", "Generative AI techniques are methods for generating new content like text, images, music, or other data, often mimicking some aspects of human creativity.\n", "\n", "Unlike supervised learning, which involves learning from *labeled* data, generative AI aims to learn the underlying patters, features, and distributions of a dataset so that it can generate new, similar data. Hence, it is a form of *unsupervised* learning. \n", "\n", "Two core methods in generative AI are **variational autoencoders** (VAEs) and **generative adversarial networks** (GANs). In this notebook we review VAEs and GANs. We then provide an overview of how **large language models** (LLMs) are trained." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Variational Autoencoders (VAEs)\n", "\n", "VAEs are trained from a data set like a set of images. They learn to create new rows (data points) that resemble those in the provided data set. They do this by converting this unsupervised learning problem into a supervised learning problem, and then applying the methods that we have discussed (gradient descent on a loss function for a parametric model).\n", "\n", "Specifically, VAEs take an input, $X_i$, and try to output $X_i$. That is, their loss function measures how close the output is to the input, $X_i$. Such a loss function is called a **reconstruction loss**. For image data, the *mean squared error* (MSE) between the pixel values of the original and reconstructed images is one common choice.\n", "\n", "This may seem simple: just define a parametric model that maps the input to the output! The key insight in VAEs is that the parametric model can be deliberately constructed to force the model to do more than this. The diagram below depicts a common *artificial neural network* (ANN) architecture for a VAE:\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The smaller boxes in the middle represent layers with fewer units. In order to reconstruct the input, $x$, with this architecture, the network must learn a smaller representation that incodes the content of the image. This smaller representation is called an **embedding** or a **latent representation**. This figure writes **latent space** to denote the space of all vectors that can be represented by the middle layer.\n", "\n", "As an exmaple, consider the problem of reconstructing images of cats. The input might be a large high-resolution RGB image. Even at a resolution of 1024x768 (with three channels, R,G, and B), an image is represented as 2,359,296 numbers. If the latent space is represented by a layer with 100 units, the network must learn to represent the entire image (2,359,296 numbers) with just 100 numbers! To do this, it might learn features like the breed of the cat (to determine the color), the age of the cat, the angle of the cat, whether the background is indoors or outdoors, etc.\n", "\n", "Intuitively, the \"Encoder\" part of the network (the part of the network before the bottleneck of a small layer that is the latent space) will learn to map an image into the latent space (into the smaller representation describing the image). The \"Decoder\" part of the network (the part of the network after the bottleneck) will then learn to map this latent representation back to an image.\n", "\n", "Note that none of this behavior is hard-coded into the methods. The network is simply designed to have a small layer in the middle, and then trained to minimize the reconstruction loss. The network then creates an encoder and decoder on its own!\n", "\n", "Once an encoder and decoder have been trained, you can generate new images by providing random vectors as input to the decoder, essentially \"making up\" the representation is latent space and asking the decoder to reconstruct the image.\n", "\n", "However, without additional mechanisms, the autoencoder may learn to only use certain values in the latent space, and so new random vectors in the latent space may not map to meaningful images. **Variational** autoencoders modify the reconstruction loss function to also encourage the network to make the latent representation have a Gaussian distribution. This way, new outputs can be generated by sampling vectors of Gaussian noise and treating them as the latent representation to be decoded. The details of this process is beyond the scope of this class, but note that one common reconstruction loss for autoencoders is called the **evidence lower bound** or (ELBO). This is simply a loss function that balances A) ensuring that the distribution of latent representations that results from the training data is roughly Gaussian, with B) the objective of reconstructing the output." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example VAE\n", "\n", "Although the details are beyond the scope of this course, notice that training a VAE in PyTorch is not significantly different from the classification and regression examples we have seen. The main difference is that the forwards pass doesn't just output the attempted reconstruction of the image: it also outputs information related to the latent representation of the image. This is necessary for the loss function to push the network towards a latent representation of the input data that is Gaussian." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torchvision\n", "from torch import nn, optim\n", "from torchvision import transforms\n", "from torch.nn import functional as F\n", "import matplotlib.pyplot as plt\n", "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# VAE model\n", "class VAE(nn.Module):\n", " def __init__(self):\n", " super(VAE, self).__init__() # Call the nn.Module initializer\n", " self.fc1 = nn.Linear(784, 400)\n", " self.fc21 = nn.Linear(400, 20) # mu layer (mean of the Gaussian)\n", " self.fc22 = nn.Linear(400, 20) # logvar layer (log of the variance)\n", " self.fc3 = nn.Linear(20, 400)\n", " self.fc4 = nn.Linear(400, 784)\n", "\n", " def encode(self, x):\n", " h1 = F.relu(self.fc1(x))\n", " return self.fc21(h1), self.fc22(h1)\n", "\n", " def reparameterize(self, mu, logvar):\n", " std = torch.exp(0.5*logvar)\n", " eps = torch.randn_like(std) # The length is that of \"std\", but these are samples of N(0,1)\n", " return mu + eps*std\n", "\n", " def decode(self, z):\n", " h3 = F.relu(self.fc3(z))\n", " return torch.sigmoid(self.fc4(h3))\n", "\n", " def forward(self, x):\n", " mu, logvar = self.encode(x.view(-1, 784))\n", " z = self.reparameterize(mu, logvar)\n", " return self.decode(z), mu, logvar" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Loss function (ELBO)\n", "def loss_function(recon_x, x, mu, logvar):\n", " BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), reduction='sum')\n", " KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n", " return BCE + KLD" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", "Failed to download (trying next):\n", "HTTP Error 404: Not Found\n", "\n", "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n", "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to ./data\\MNIST\\raw\\train-images-idx3-ubyte.gz\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 9912422/9912422 [00:00<00:00, 51984454.62it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Extracting ./data\\MNIST\\raw\\train-images-idx3-ubyte.gz to ./data\\MNIST\\raw\n", "\n", "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", "Failed to download (trying next):\n", "HTTP Error 404: Not Found\n", "\n", "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n", "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to ./data\\MNIST\\raw\\train-labels-idx1-ubyte.gz\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 28881/28881 [00:00<00:00, 1806593.30it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Extracting ./data\\MNIST\\raw\\train-labels-idx1-ubyte.gz to ./data\\MNIST\\raw\n", "\n", "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", "Failed to download (trying next):\n", "HTTP Error 404: Not Found\n", "\n", "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n", "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to ./data\\MNIST\\raw\\t10k-images-idx3-ubyte.gz\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 1648877/1648877 [00:00<00:00, 16074085.58it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Extracting ./data\\MNIST\\raw\\t10k-images-idx3-ubyte.gz to ./data\\MNIST\\raw\n", "\n", "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", "Failed to download (trying next):\n", "HTTP Error 404: Not Found\n", "\n", "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n", "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to ./data\\MNIST\\raw\\t10k-labels-idx1-ubyte.gz\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 4542/4542 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Generating images\n", "def show_generated_images(model, num_images=10):\n", " with torch.no_grad():\n", " z = torch.randn(num_images, 20)\n", " sample = model.decode(z).cpu()\n", " sample = sample.view(num_images, 28, 28)\n", "\n", " fig, axs = plt.subplots(1, num_images, figsize=(num_images, 1))\n", " for i in range(num_images):\n", " axs[i].imshow(sample[i].numpy(), cmap='gray')\n", " axs[i].axis('off')\n", " plt.show()\n", "\n", "show_generated_images(model)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After just 11 epochs (1.5 minutes on my CPU) of training, we're starting to see images that looks like hand-written letters! With more training these could likely be further improved." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Generative Adversarial Networks (GANs)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "GANs use two neural networks that learn from each other, competing in a king of tug-of-war. These two networks are called the **generator** and the **discriminator**.\n", "\n", "#### Generator\n", "\n", "The generator is tasked with creating fake data points (e.g., fake images). Its goal is to create images that are indistinguishable from the real ones in the data set. It starts by creating the image from random noise. That is, it takes random noise as input, and produces an image as output.\n", "\n", "#### Discriminator\n", "\n", "The discriminator takes both the fake images from the generator and the real images from the training data set as its input data (one image at a time). Its job is to learn to differentiate between the two, discerning real from fake.\n", "\n", "#### Training\n", "\n", "The loss function used by the generator penalizes it for producing images that the discriminator is able to detect as fakes. The loss function for the discriminator penalizes it fair failing to detect the generator's fakes.\n", "\n", "During the early stages of training, the generator's images are easily spotted as fakes. However, as training progresses, it starts to understand what makes an image more believable. It learns complex representations - not specific features like the color or shape of an object, but deeper aspects, like the way light and shadow play on surfaces or how different objects in an image relate to each other in space.\n", "\n", "What's truly remarkable is that this entire process evolves without explicit instructions on what to learn. The networks, through their adversarial training, figure out the details. Eventually, if the training is successful, the generator becomes so skilled that the discriminator can't tell its creations from real images.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Example GAN" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch [0/15], Step [100/938], d_loss: 0.1968, g_loss: 2.1253\n", "Epoch [0/15], Step [200/938], d_loss: 0.1253, g_loss: 3.2851\n", "Epoch [0/15], Step [300/938], d_loss: 0.1698, g_loss: 4.1563\n", "Epoch [0/15], Step [400/938], d_loss: 0.0610, g_loss: 5.5070\n", "Epoch [0/15], Step [500/938], d_loss: 0.0136, g_loss: 6.1925\n", "Epoch [0/15], Step [600/938], d_loss: 0.0244, g_loss: 6.1424\n", "Epoch [0/15], Step [700/938], d_loss: 0.0265, g_loss: 6.5670\n", "Epoch [0/15], Step [800/938], d_loss: 0.0337, g_loss: 6.3879\n", "Epoch [0/15], Step [900/938], d_loss: 0.0803, g_loss: 7.4044\n", "Epoch [1/15], Step [100/938], d_loss: 0.1964, g_loss: 11.1679\n", "Epoch [1/15], Step [200/938], d_loss: 0.1964, g_loss: 6.7413\n", "Epoch [1/15], Step [300/938], d_loss: 0.1970, g_loss: 3.5620\n", "Epoch [1/15], Step [400/938], d_loss: 0.2756, g_loss: 5.0921\n", "Epoch [1/15], Step [500/938], d_loss: 0.3247, g_loss: 4.7702\n", "Epoch [1/15], Step [600/938], d_loss: 0.3061, g_loss: 4.3312\n", "Epoch [1/15], Step [700/938], d_loss: 0.2647, g_loss: 6.2605\n", "Epoch [1/15], Step [800/938], d_loss: 0.3247, g_loss: 3.7898\n", "Epoch [1/15], Step [900/938], d_loss: 0.5217, g_loss: 3.3301\n", "Epoch [2/15], Step [100/938], d_loss: 0.2458, g_loss: 2.7131\n", "Epoch [2/15], Step [200/938], d_loss: 0.4238, g_loss: 4.3987\n", "Epoch [2/15], Step [300/938], d_loss: 0.5795, g_loss: 2.4602\n", "Epoch [2/15], Step [400/938], d_loss: 0.5659, g_loss: 3.4101\n", "Epoch [2/15], Step [500/938], d_loss: 0.4948, g_loss: 3.2021\n", "Epoch [2/15], Step [600/938], d_loss: 0.4680, g_loss: 3.7562\n", "Epoch [2/15], Step [700/938], d_loss: 0.6839, g_loss: 2.6689\n", "Epoch [2/15], Step [800/938], d_loss: 0.8165, g_loss: 3.4143\n", "Epoch [2/15], Step [900/938], d_loss: 0.4250, g_loss: 2.2062\n", "Epoch [3/15], Step [100/938], d_loss: 0.5896, g_loss: 2.6581\n", "Epoch [3/15], Step [200/938], d_loss: 0.4780, g_loss: 3.5904\n", "Epoch [3/15], Step [300/938], d_loss: 0.6242, g_loss: 2.2625\n", "Epoch [3/15], Step [400/938], d_loss: 0.6681, g_loss: 2.8004\n", "Epoch [3/15], Step [500/938], d_loss: 0.7445, g_loss: 3.0726\n", "Epoch [3/15], Step [600/938], d_loss: 0.5506, g_loss: 3.5891\n", "Epoch [3/15], Step [700/938], d_loss: 0.7191, g_loss: 2.5736\n", "Epoch [3/15], Step [800/938], d_loss: 0.7074, g_loss: 2.7978\n", "Epoch [3/15], Step [900/938], d_loss: 0.5882, g_loss: 1.9058\n", "Epoch [4/15], Step [100/938], d_loss: 0.9155, g_loss: 1.6220\n", "Epoch [4/15], Step [200/938], d_loss: 0.6090, g_loss: 2.3546\n", "Epoch [4/15], Step [300/938], d_loss: 0.7083, g_loss: 2.6362\n", "Epoch [4/15], Step [400/938], d_loss: 0.8851, g_loss: 1.7231\n", "Epoch [4/15], Step [500/938], d_loss: 0.7574, g_loss: 1.7395\n", "Epoch [4/15], Step [600/938], d_loss: 0.8677, g_loss: 2.0268\n", "Epoch [4/15], Step [700/938], d_loss: 0.6598, g_loss: 1.8621\n", "Epoch [4/15], Step [800/938], d_loss: 0.6667, g_loss: 2.3757\n", "Epoch [4/15], Step [900/938], d_loss: 0.5857, g_loss: 1.9318\n", "Epoch [5/15], Step [100/938], d_loss: 0.6102, g_loss: 2.1001\n", "Epoch [5/15], Step [200/938], d_loss: 0.7180, g_loss: 2.3402\n", "Epoch [5/15], Step [300/938], d_loss: 0.6467, g_loss: 2.7362\n", "Epoch [5/15], Step [400/938], d_loss: 0.8340, g_loss: 1.7500\n", "Epoch [5/15], Step [500/938], d_loss: 0.6634, g_loss: 1.8997\n", "Epoch [5/15], Step [600/938], d_loss: 0.8033, g_loss: 2.6520\n", "Epoch [5/15], Step [700/938], d_loss: 0.9429, g_loss: 1.7822\n", "Epoch [5/15], Step [800/938], d_loss: 0.8467, g_loss: 2.0240\n", "Epoch [5/15], Step [900/938], d_loss: 0.6981, g_loss: 2.1250\n", "Epoch [6/15], Step [100/938], d_loss: 0.9844, g_loss: 1.8475\n", "Epoch [6/15], Step [200/938], d_loss: 0.7247, g_loss: 2.3818\n", "Epoch [6/15], Step [300/938], d_loss: 0.7758, g_loss: 1.2705\n", "Epoch [6/15], Step [400/938], d_loss: 0.6998, g_loss: 2.2222\n", "Epoch [6/15], Step [500/938], d_loss: 0.9477, g_loss: 1.8426\n", "Epoch [6/15], Step [600/938], d_loss: 0.6771, g_loss: 1.9632\n", "Epoch [6/15], Step [700/938], d_loss: 0.9380, g_loss: 1.7148\n", "Epoch [6/15], Step [800/938], d_loss: 0.6734, g_loss: 1.9416\n", "Epoch [6/15], Step [900/938], d_loss: 0.8901, g_loss: 1.5339\n", "Epoch [7/15], Step [100/938], d_loss: 0.9863, g_loss: 1.7283\n", "Epoch [7/15], Step [200/938], d_loss: 0.7632, g_loss: 2.4689\n", "Epoch [7/15], Step [300/938], d_loss: 0.9671, g_loss: 1.7843\n", "Epoch [7/15], Step [400/938], d_loss: 0.7342, g_loss: 1.7388\n", "Epoch [7/15], Step [500/938], d_loss: 0.7367, g_loss: 1.4516\n", "Epoch [7/15], Step [600/938], d_loss: 0.9533, g_loss: 1.7038\n", "Epoch [7/15], Step [700/938], d_loss: 0.9913, g_loss: 2.5165\n", "Epoch [7/15], Step [800/938], d_loss: 0.6771, g_loss: 1.8887\n", "Epoch [7/15], Step [900/938], d_loss: 0.8115, g_loss: 2.2673\n", "Epoch [8/15], Step [100/938], d_loss: 0.8134, g_loss: 2.1915\n", "Epoch [8/15], Step [200/938], d_loss: 0.7089, g_loss: 2.4003\n", "Epoch [8/15], Step [300/938], d_loss: 0.9474, g_loss: 1.8414\n", "Epoch [8/15], Step [400/938], d_loss: 0.9899, g_loss: 1.6218\n", "Epoch [8/15], Step [500/938], d_loss: 0.8158, g_loss: 1.9243\n", "Epoch [8/15], Step [600/938], d_loss: 0.7556, g_loss: 1.8116\n", "Epoch [8/15], Step [700/938], d_loss: 0.7415, g_loss: 2.0091\n", "Epoch [8/15], Step [800/938], d_loss: 0.6599, g_loss: 2.2918\n", "Epoch [8/15], Step [900/938], d_loss: 0.8394, g_loss: 2.2152\n", "Epoch [9/15], Step [100/938], d_loss: 0.8547, g_loss: 2.2970\n", "Epoch [9/15], Step [200/938], d_loss: 0.9285, g_loss: 2.1147\n", "Epoch [9/15], Step [300/938], d_loss: 0.9043, g_loss: 2.4567\n", "Epoch [9/15], Step [400/938], d_loss: 1.0239, g_loss: 1.4896\n", "Epoch [9/15], Step [500/938], d_loss: 0.7885, g_loss: 1.6315\n", "Epoch [9/15], Step [600/938], d_loss: 0.6050, g_loss: 1.9700\n", "Epoch [9/15], Step [700/938], d_loss: 0.7771, g_loss: 1.6589\n", "Epoch [9/15], Step [800/938], d_loss: 0.7726, g_loss: 1.6334\n", "Epoch [9/15], Step [900/938], d_loss: 0.9044, g_loss: 2.0588\n", "Epoch [10/15], Step [100/938], d_loss: 0.9735, g_loss: 2.0161\n", "Epoch [10/15], Step [200/938], d_loss: 0.7590, g_loss: 2.6000\n", "Epoch [10/15], Step [300/938], d_loss: 0.7545, g_loss: 1.9695\n", "Epoch [10/15], Step [400/938], d_loss: 0.6759, g_loss: 2.0362\n", "Epoch [10/15], Step [500/938], d_loss: 0.6649, g_loss: 1.5897\n", "Epoch [10/15], Step [600/938], d_loss: 0.8588, g_loss: 1.8251\n", "Epoch [10/15], Step [700/938], d_loss: 0.6679, g_loss: 2.3880\n", "Epoch [10/15], Step [800/938], d_loss: 0.7888, g_loss: 1.7575\n", "Epoch [10/15], Step [900/938], d_loss: 0.9048, g_loss: 1.1682\n", "Epoch [11/15], Step [100/938], d_loss: 0.8266, g_loss: 1.4023\n", "Epoch [11/15], Step [200/938], d_loss: 0.8397, g_loss: 1.3329\n", "Epoch [11/15], Step [300/938], d_loss: 0.7491, g_loss: 1.8133\n", "Epoch [11/15], Step [400/938], d_loss: 0.9517, g_loss: 1.9995\n", "Epoch [11/15], Step [500/938], d_loss: 0.8492, g_loss: 1.2039\n", "Epoch [11/15], Step [600/938], d_loss: 0.9957, g_loss: 1.6000\n", "Epoch [11/15], Step [700/938], d_loss: 0.6942, g_loss: 1.1894\n", "Epoch [11/15], Step [800/938], d_loss: 0.7000, g_loss: 2.2242\n", "Epoch [11/15], Step [900/938], d_loss: 0.7945, g_loss: 1.6052\n", "Epoch [12/15], Step [100/938], d_loss: 0.8775, g_loss: 1.5036\n", "Epoch [12/15], Step [200/938], d_loss: 1.1906, g_loss: 1.6118\n", "Epoch [12/15], Step [300/938], d_loss: 1.0698, g_loss: 1.4668\n", "Epoch [12/15], Step [400/938], d_loss: 1.1755, g_loss: 1.7004\n", "Epoch [12/15], Step [500/938], d_loss: 0.8775, g_loss: 1.9998\n", "Epoch [12/15], Step [600/938], d_loss: 0.9339, g_loss: 2.0696\n", "Epoch [12/15], Step [700/938], d_loss: 0.6873, g_loss: 1.9389\n", "Epoch [12/15], Step [800/938], d_loss: 0.8550, g_loss: 1.9689\n", "Epoch [12/15], Step [900/938], d_loss: 0.6931, g_loss: 2.1201\n", "Epoch [13/15], Step [100/938], d_loss: 0.6622, g_loss: 2.2526\n", "Epoch [13/15], Step [200/938], d_loss: 0.6650, g_loss: 2.4257\n", "Epoch [13/15], Step [300/938], d_loss: 0.9299, g_loss: 2.2868\n", "Epoch [13/15], Step [400/938], d_loss: 0.9252, g_loss: 1.6538\n", "Epoch [13/15], Step [500/938], d_loss: 0.9582, g_loss: 1.5898\n", "Epoch [13/15], Step [600/938], d_loss: 0.7105, g_loss: 2.0934\n", "Epoch [13/15], Step [700/938], d_loss: 0.6426, g_loss: 2.4876\n", "Epoch [13/15], Step [800/938], d_loss: 0.8371, g_loss: 1.9572\n", "Epoch [13/15], Step [900/938], d_loss: 0.9026, g_loss: 1.5870\n", "Epoch [14/15], Step [100/938], d_loss: 0.8441, g_loss: 1.7409\n", "Epoch [14/15], Step [200/938], d_loss: 1.1538, g_loss: 2.4822\n", "Epoch [14/15], Step [300/938], d_loss: 0.8320, g_loss: 2.2448\n", "Epoch [14/15], Step [400/938], d_loss: 1.0065, g_loss: 1.7845\n", "Epoch [14/15], Step [500/938], d_loss: 1.2467, g_loss: 1.5347\n", "Epoch [14/15], Step [600/938], d_loss: 0.9260, g_loss: 1.8226\n", "Epoch [14/15], Step [700/938], d_loss: 0.8086, g_loss: 1.5104\n", "Epoch [14/15], Step [800/938], d_loss: 0.9717, g_loss: 1.4188\n", "Epoch [14/15], Step [900/938], d_loss: 0.9018, g_loss: 2.4415\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import torch\n", "import torchvision\n", "import torchvision.transforms as transforms\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "from torch.autograd import Variable\n", "import matplotlib.pyplot as plt\n", "\n", "# Hyperparameters\n", "batch_size = 64\n", "learning_rate = 0.0002\n", "epochs = 15\n", "\n", "# MNIST Dataset\n", "transform = transforms.Compose([\n", " transforms.ToTensor(),\n", " transforms.Normalize(mean=(0.5,), std=(0.5,))\n", "])\n", "\n", "train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n", "\n", "# Discriminator\n", "class Discriminator(nn.Module):\n", " def __init__(self):\n", " super(Discriminator, self).__init__()\n", " self.fc = nn.Sequential(\n", " nn.Linear(784, 256),\n", " nn.LeakyReLU(0.2),\n", " nn.Linear(256, 256),\n", " nn.LeakyReLU(0.2),\n", " nn.Linear(256, 1),\n", " nn.Sigmoid()\n", " )\n", "\n", " def forward(self, x):\n", " x = x.view(x.size(0), -1)\n", " return self.fc(x)\n", "\n", "# Generator\n", "class Generator(nn.Module):\n", " def __init__(self):\n", " super(Generator, self).__init__()\n", " self.fc = nn.Sequential(\n", " nn.Linear(100, 256),\n", " nn.LeakyReLU(0.2),\n", " nn.BatchNorm1d(256),\n", " nn.Linear(256, 256),\n", " nn.LeakyReLU(0.2),\n", " nn.BatchNorm1d(256),\n", " nn.Linear(256, 784),\n", " nn.Tanh()\n", " )\n", "\n", " def forward(self, x):\n", " return self.fc(x)\n", "\n", "discriminator = Discriminator()\n", "generator = Generator()\n", "\n", "# Loss and Optimizer\n", "criterion = nn.BCELoss()\n", "d_optimizer = optim.Adam(discriminator.parameters(), lr=learning_rate)\n", "g_optimizer = optim.Adam(generator.parameters(), lr=learning_rate)\n", "\n", "# Training\n", "for epoch in range(epochs):\n", " for i, (images, _) in enumerate(train_loader):\n", " current_batch_size = images.size(0)\n", "\n", " # Train Discriminator\n", " real_images = Variable(images.view(current_batch_size, -1))\n", " real_labels = Variable(torch.ones(current_batch_size, 1))\n", " fake_labels = Variable(torch.zeros(current_batch_size, 1))\n", "\n", " # Real images loss\n", " outputs = discriminator(real_images)\n", " d_loss_real = criterion(outputs, real_labels)\n", "\n", " # Fake images loss\n", " z = Variable(torch.randn(current_batch_size, 100))\n", " fake_images = generator(z)\n", " outputs = discriminator(fake_images)\n", " d_loss_fake = criterion(outputs, fake_labels)\n", "\n", " # Backprop and optimize\n", " d_loss = d_loss_real + d_loss_fake\n", " d_optimizer.zero_grad()\n", " g_optimizer.zero_grad()\n", " d_loss.backward()\n", " d_optimizer.step()\n", "\n", " # Train Generator\n", " z = Variable(torch.randn(current_batch_size, 100))\n", " fake_images = generator(z)\n", " outputs = discriminator(fake_images)\n", " g_loss = criterion(outputs, real_labels)\n", "\n", " # Backprop and optimize\n", " d_optimizer.zero_grad()\n", " g_optimizer.zero_grad()\n", " g_loss.backward()\n", " g_optimizer.step()\n", "\n", " if (i + 1) % 100 == 0:\n", " print(f'Epoch [{epoch}/{epochs}], Step [{i+1}/{len(train_loader)}], d_loss: {d_loss.item():.4f}, g_loss: {g_loss.item():.4f}')\n", "\n", "# Generate and show images\n", "def show_generated_images(generator, num_images=10):\n", " z = torch.randn(num_images, 100)\n", " fake_images = generator(z)\n", " fake_images = fake_images.view(fake_images.size(0), 28, 28)\n", " fake_images = (fake_images + 1) / 2 # Rescale to [0, 1]\n", "\n", " fig, axs = plt.subplots(1, num_images, figsize=(num_images, 1))\n", " for i in range(num_images):\n", " axs[i].imshow(fake_images[i].detach().numpy(), cmap='gray')\n", " axs[i].axis('off')\n", "\n", " plt.show()\n", "\n", "show_generated_images(generator)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Beyond VAEs and GANs\n", "\n", "Generative AI methods have been advancing rapidly. Note that current state of the art methods for generating images (or videos) from text prompts are not VAEs or GANs (DALL-E 1 was a variant of a VAE, but DALL-E 2 is not). More recent methods use **diffusion models**, which start with a pattern of random noise and then gradually transform this pattern into a coherent image. This transformation occurs in steps, each slightly reducing the randomness and shaping the noise into an image that corresponds to a given text input. For more on advanced generative AI techniques, I recommend taking COMPSCI 670, Computer Vision." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Large Language Models (LLMs)\n", "\n", "*Large language models* (LLMs) are parametric models applied to text (or audio). Models like GPT-4 are based on *transformers*, a type of artificial neural network architecture. \n", "\n", "ChatGPT using GPT-4 claims that it has 175 billion tunable parameters. The wikipedia page suggests 1 trillion to 1.76 trillion parameters. It was trained on 13 trillion tokens, or roughly 10 trillion words (roughly 50 terabytes of data).\n", "\n", "Perhaps surprisingly, GPT-4 uses supervised learning: given the tokens (words and parts of words) seen so far, it attempts to predict what the next word will be. Training such a large network on so much data was estimated to have cost roughly $60-$100 million.\n", "\n", "More specifically, the model takes as input the most recent \"tokens\" (parts of words), up to 32,768 tokens, and predicts what the next token will be. After training using supervised learning, a form of reinforcement learning from human feedback (RLHF) was used to finetune the model to produce more desirable answers to prompts.\n", "\n", "While there are some properties that are beyond the scope of this course (e.g., the details of the transformer architecture and the use of a mixture of experts), the core technology underlying GPT-4 and hence ChatGPT is simply a large parametric model trained using gradient descent on a large amount of data." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.7" } }, "nbformat": 4, "nbformat_minor": 2 }